<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>实现数组的方法</title>
</head>

<body>
    <script>
        // push() 向数组中添加数据
        let arr = [11, 22, 33]
        function push(v) {
            arr[arr.length] = v
        }
        push(44)
        push(55)
        console.log(arr);
        console.log('-'.repeat(50));
        // pop()方法，用于删除并返回数组中最后一个元素
        function pop() {
            let last = arr[arr.length - 1]
            arr.length -= 1
            return last
        }
        let last = pop()
        console.log(arr);
        console.log(last);
        console.log('-'.repeat(50));
        // unshift()方法，用于向数组的开头添加数据
        function unshift(a) {
            for (let i = arr.length - 1; i >= 0; i--) {
                arr[i + 1] = arr[i]
            }
            arr[0] = a
        }
        unshift(100)
        unshift(200)
        console.log(arr);

        console.log('-'.repeat(50));

        // shift()方法，用于删除并返回数组中的第一个元素
        function shift() {
            let first = arr[0]
            for (let i = 0; i < arr.length; i++) {
                arr[i] = arr[i + 1]
            }
            arr.length -= 1
            return first
        }
        let first = shift()
        console.log(first);
        console.log(arr);

        console.log('-'.repeat(50));

        // indexOf()用于从数组中查找指定的数据第一次出现的 位置（下标）

        function indexOf(v) {
            let index = -1
            for (let i = 0; i <= arr.length; i++) {
                if (arr[i] === v) {
                    index = i
                    break
                }
            }
            return index
        }
        let index1 = indexOf(33)
        console.log(index1);
        let index2 = indexOf(10)
        console.log(index2);

        console.log('-'.repeat(50));

        // lastIndexOf() 方法用于从数组中查找指定的数据最后一次出现的位置


        function lastIndexOf(v) {
            let index = -1
            for (let i = arr.length; i >= 0; i--) {
                if (arr[i] === v) {
                    index = i
                    break
                }
            }
            return index
        }

        let index3 = lastIndexOf(22)
        console.log(index3);
        console.log('-'.repeat(50));

        // slice()方法，返回数组中指定区间的数据,第一个参数是起始下标，第二个参数是结束下标
        console.log(arr);

        function slice(a, b) {
            let x = []
            if (b > arr.length) {
                b = arr.length
            }
            for (let i = a; i < b; i++) {
                x.push(arr[i])

            }

            return x
        }
        let c = slice(1, 30)
        console.log(c);
        console.log('-'.repeat(50));

        // includes()方法，用于从数组中查找指定的数据是否存在，存在返回true，否则返回false
        function includes(v) {
            let buer = false
            for (let i = 0; i < arr.length; i++) {
                if (v === arr[i]) {
                    buer = true
                    break
                }
            }
            return buer
        }

        let d = includes(10)
        console.log(d);
        console.log('-'.repeat(50));

        // splice()方法，用于删除数组中指定长度的数据
        let arr1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

        function splice(s, len) {
            for (let i = s; i < s + len; i++) {
                arr1[i] = arr1[i + len]
            }
            arr1.length -= len
        }
        // console.log(arr1);
        // splice(2, 3)
        // console.log(arr1);





        // function splice(a, b) {
        //     let zf = []
        //     for (let i = 0; i <= arr1.length - 1; i++) {

        //         if (i == a) {
        //             i += b - 1
        //             continue
        //         } else {

        //             zf.push(arr1[i])
        //         }
        //     }

        //     return zf
        // }

        // let f = splice(1, 3)
        // console.log(f);

        // let g = splice(7, 2)
        // console.log(g);

        // function splice(s,len) {
        //     for(let i = s; i<s+len;i++){
        //         arr1[i] = arr1[i+len]
        //     }
        //     arr1.length-=len
        // }
        // console.log(arr1);
        // splice(1,3)
        // console.log(arr1);

        function join(split = ',') {
            let str = ''
            for (let i = 0; i < arr.length; i++) {

                str += arr[i]
                if (i < arr.length - 1) {
                    str += split
                }
            }
            return str
        }

        console.log(join('-'));

        // reverse()方法，用于翻转数组中的数据
        console.log('-'.repeat(50));
        // 不知道对不对 应该是对的
        //     console.log(arr1);
        //     function reverse() {
        //         let arr2 = []
        //         for (var i = 0; i <= arr1.length-1; i++) {
        //             arr2[i] = arr1[arr1.length-1 -i]
        //         }
        //         arr1 = arr2 
        //         return arr1
        //     }

        //   console.log(reverse());

        // console.log(arr);
        // arr = push(55)
        console.log(arr);
        arr = [11, 22, 33, 44, 55]
        function reverse() {
            for (let i = 0; i < Math.floor(arr.length / 2); i++) {
                // console.log(i);
                if (arr[i] !== arr[arr.length - 1 - i]) {
                    let temp = arr[i]
                    arr[i] = arr[arr.length - 1 - i]
                    arr[arr.length - 1 - i] = temp
                }
            }
            return arr
        }

        reverse()
        console.log('-+-+-+-+-+');

        console.log(arr); //[55, 44, 33, 22, 11]

        // sort()方法，用于对数组中的数据排序
        // 冒泡排序
        function sort() {
            // 外层循环控制比较轮数
            for (let i = 0; i < arr.length - 1; i++) {
                // 内存循环，控制每轮的比较次数
                for (let j = 0; j < arr.length - 1; j++) {
                    // 每一轮，都是前面的数跟后面的数比较
                    if (arr[j] > arr[j + 1]) {
                        // 如果前面的数大于 后面的数
                        // 这两个数 换位置
                        let temp = arr[j]   // 借助中间变量
                        arr[j] = arr[j + 1]
                        arr[j + 1] = temp
                    }
                }
            }
        }
        sort()
        console.log(arr); //[11, 22, 33, 44, 55]



        console.log('-+-+-+-+-+');
        // console.log(arr1);
        //  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
        // concat()方法，用于对两个数组中的数据拼接，并返回新的数组
        function concat(new_arr) {
            let ret_arr = []
            for(let i =0;i<arr1.length;i++){
                ret_arr.push(arr1[i])
            }
            for(let i = 0;i<new_arr.length;i++){
                ret_arr.push(new_arr[i])
            }
            return ret_arr
        }

        

        console.log(concat([11, 12, 13, 14, 15]));










    </script>
</body>

</html>